home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / circuits / irsim-9.000 / irsim-9 / src / irsim / usage.c < prev    next >
C/C++ Source or Header  |  1994-10-17  |  7KB  |  305 lines
  1. /* 
  2.  *     ********************************************************************* 
  3.  *     * Copyright (C) 1988, 1990 Stanford University.                     * 
  4.  *     * Permission to use, copy, modify, and distribute this              * 
  5.  *     * software and its documentation for any purpose and without        * 
  6.  *     * fee is hereby granted, provided that the above copyright          * 
  7.  *     * notice appear in all copies.  Stanford University                 * 
  8.  *     * makes no representations about the suitability of this            * 
  9.  *     * software for any purpose.  It is provided "as is" without         * 
  10.  *     * express or implied warranty.  Export of this software outside     * 
  11.  *     * of the United States of America may require an export license.    * 
  12.  *     ********************************************************************* 
  13.  */
  14.  
  15.  
  16. #ifdef SYS_V
  17.  
  18. #include <stdio.h>
  19. #include <sys/types.h>
  20. #include <sys/times.h>
  21. #include <sys/param.h>
  22. #include "defs.h"
  23.  
  24.  
  25.     /* time and usage at program start */
  26. private    time_t      time0;
  27. private struct tms  ru0;
  28.  
  29.     /* time and usage before command is executed */
  30. private    time_t      time1, t_usr;
  31. private struct tms  ru1, ru_usr;
  32.  
  33. private    long mem0;
  34.  
  35.  
  36. public void InitUsage()
  37.   {
  38.     time0 = time( 0 );
  39.     (void) times( &ru0 );
  40.     mem0 = (long) sbrk( 0 );
  41.   }
  42.  
  43. public void set_usage()
  44.   {
  45.     time1 = time( 0 );
  46.     (void) times( &ru1 );
  47.   }
  48.  
  49. public void uset_usage()
  50.   {
  51.     t_usr = time( 0 );
  52.     (void) times( &ru_usr );
  53.   }
  54.  
  55.  
  56. private char *pr_secs( dst, l )
  57.   char  *dst;
  58.   long  l;
  59.   {
  60.     register int  i;
  61.  
  62.     i = l / 3600;
  63.     if( i != 0 )
  64.       {
  65.     (void) sprintf( dst, "%d:%02d", i, (l % 3600) / 60 );
  66.     i = l % 3600;
  67.       }
  68.     else
  69.       {
  70.     i = l;
  71.     (void) sprintf( dst, "%d", i / 60 );
  72.       }
  73.     while( *++dst );
  74.  
  75.     i %= 60;
  76.     *dst++ = ':';
  77.     (void) sprintf( dst, "%02d ", i );
  78.     dst += 3;
  79.     return( dst );
  80.   }
  81.  
  82.  
  83. private void pr_usage( dst, r0, r1, t0, t1 )
  84.   register char         *dst;
  85.   register struct  tms  *r0, *r1;
  86.   register time_t       *t0, *t1;
  87.   {
  88.     register time_t  t, dt;
  89.     int      mem;
  90.  
  91.     dt = r1->tms_utime - r0->tms_utime;
  92.     (void) sprintf( dst, "%d.%01du ", dt / HZ, dt / (HZ / 10) );
  93.     while( *++dst );
  94.  
  95.     dt = r1->tms_stime - r0->tms_stime;
  96.     (void) sprintf( dst, "%d.%01ds ", dt / HZ, dt / (HZ / 10) );
  97.     while( *++dst );
  98.  
  99.     t = *t1 - *t0;
  100.     dst = pr_secs( dst, (long) t );
  101.  
  102.     dt = r1->tms_utime - r0->tms_utime + r1->tms_stime - r0->tms_stime;
  103.     t *= HZ;
  104.  
  105.     (void) sprintf( dst, "%d%% ", (int) (dt * 100 / ( (t ? t : 1 ) )) );
  106.     while( *++dst );
  107.  
  108.     mem = sbrk( 0 ) - mem0;
  109.     (void) sprintf( dst, "%dK\n", mem / 1024 );
  110.   }
  111.  
  112.  
  113. public void print_usage( partial, dest )
  114.   int   partial;
  115.   char  *dest;
  116.   {
  117.     time_t      time2;
  118.     struct tms  ru2;
  119.  
  120.     time2 = time( 0 );
  121.     (void) times( &ru2 );
  122.  
  123.     if( partial )
  124.     pr_usage( dest, &ru1, &ru2, &time1, &time2 );
  125.     else
  126.     pr_usage( dest, &ru0, &ru2, &time0, &time2 );
  127.   }
  128.  
  129.  
  130. public void get_usage( dest )
  131.   register char  *dest;
  132.   {
  133.     time_t           time2;
  134.     struct tms       ru2;
  135.     register time_t  dt;
  136.     time_t           msu, mss, ms;
  137.  
  138.     time2 = time( 0 );
  139.     (void) times( &ru2 );
  140.  
  141.     dt = ru2.tms_utime - ru_usr.tms_utime;
  142.     msu = dt * 1000 / HZ;
  143.  
  144.     dt = ru2.tms_stime - ru_usr.tms_stime;
  145.     mss = dt * 1000 / HZ;
  146.  
  147.     dt = time2 - t_usr;
  148.     (void) sprintf( dest, "%ldu %lds %ldsec", msu, mss, dt );
  149.   }
  150.  
  151. #else            /* BSD */
  152.  
  153. #include <stdio.h>
  154. #include <sys/types.h>
  155. #include <sys/time.h>
  156. #include <sys/resource.h>
  157. #include "defs.h"
  158.  
  159.  
  160.     /* time and usage at program start */
  161. private    struct timeval    time0;
  162. private struct rusage     ru0;
  163.  
  164.     /* time and usage before command is executed */
  165. private    struct timeval    time1, t_usr;
  166. private struct rusage     ru1, ru_usr;
  167.  
  168.  
  169. public void InitUsage()
  170.   {
  171.     (void) gettimeofday( &time0, (struct timezone *) 0 );
  172.     (void) getrusage( RUSAGE_SELF, &ru0 );
  173.   }
  174.  
  175.  
  176. public void set_usage()
  177.   {
  178.     (void) gettimeofday( &time1, (struct timezone *) 0 );
  179.     (void) getrusage( RUSAGE_SELF, &ru1 );
  180.   }
  181.  
  182. public void uset_usage()
  183.   {
  184.     (void) gettimeofday( &t_usr, (struct timezone *) 0 );
  185.     (void) getrusage( RUSAGE_SELF, &ru_usr );
  186.   }
  187.  
  188.  
  189. private void tvsub( tdiff, t1, t0 )
  190.   struct timeval *tdiff, *t1, *t0;
  191.   {
  192.     tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
  193.     tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
  194.     if (tdiff->tv_usec < 0)
  195.       {
  196.     tdiff->tv_sec--;
  197.     tdiff->tv_usec += 1000000;
  198.       }
  199.   }
  200.  
  201.  
  202. private char *pr_secs( dst, l )
  203.   char  *dst;
  204.   long  l;
  205.   {
  206.     register int  i;
  207.  
  208.     i = l / 3600;
  209.     if( i != 0 )
  210.       {
  211.     (void) sprintf( dst, "%d:%02d", i, (l % 3600) / 60 );
  212.     i = l % 3600;
  213.       }
  214.     else
  215.       {
  216.     i = l;
  217.     (void) sprintf( dst, "%d", i / 60 );
  218.       }
  219.     while( *++dst );
  220.  
  221.     i %= 60;
  222.     *dst++ = ':';
  223.     (void) sprintf( dst, "%02d ", i );
  224.     dst += 3;
  225.     return( dst );
  226.   }
  227.  
  228.  
  229. #define    u2m( A )    ( (A) / 10000 )        /* usec to msec */
  230. #define    u2d( A )    ( (A) / 100000 )    /* usec to 10th sec */
  231.  
  232. private void pr_usage( dst, r0, r1, t0, t1 )
  233.   register char            *dst;
  234.   register struct rusage   *r0, *r1;
  235.   register struct timeval  *t0, *t1;
  236.   {
  237.     register time_t  t;
  238.     struct timeval   dt;
  239.     int              ms;
  240.  
  241.     tvsub( &dt, &r1->ru_utime, &r0->ru_utime );
  242.     (void) sprintf( dst, "%d.%01du ", dt.tv_sec, u2d( dt.tv_usec ) );
  243.     while( *++dst );
  244.  
  245.     tvsub( &dt, &r1->ru_stime, &r0->ru_stime );
  246.     (void) sprintf( dst, "%d.%01ds ", dt.tv_sec, u2d( dt.tv_usec ) );
  247.     while( *++dst );
  248.  
  249.     ms = (t1->tv_sec - t0->tv_sec) * 100 + u2m( t1->tv_usec - t0->tv_usec);
  250.     dst = pr_secs( dst, (long) (ms / 100) );
  251.  
  252.     t = (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 100 +
  253.         u2m( r1->ru_utime.tv_usec - r0->ru_utime.tv_usec ) +
  254.         (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 100 +
  255.         u2m( r1->ru_stime.tv_usec - r0->ru_stime.tv_usec );
  256.             
  257.     (void) sprintf( dst, "%d%% ", (int) (t * 100 / ( (ms ? ms : 1 ) )) );
  258.     while( *++dst );
  259.  
  260.     (void) sprintf( dst, "%dK\n", r1->ru_maxrss / 2 );
  261.   }
  262.  
  263.  
  264. public void print_usage( partial, dest )
  265.   int   partial;
  266.   char  *dest;
  267.   {
  268.     struct timeval  time2;
  269.     struct rusage   ru2;
  270.  
  271.     (void) gettimeofday( &time2, (struct timezone *) 0 );
  272.     (void) getrusage( RUSAGE_SELF, &ru2 );
  273.  
  274.     if( partial )
  275.     pr_usage( dest, &ru1, &ru2, &time1, &time2 );
  276.     else
  277.     pr_usage( dest, &ru0, &ru2, &time0, &time2 );
  278.   }
  279.  
  280.  
  281. public void get_usage( dest )
  282.   register char  *dest;
  283.   {
  284.     struct timeval  t2;
  285.     struct rusage   ru2;
  286.     struct timeval  dt;
  287.     long            msu, mss, ms;
  288.  
  289.     (void) gettimeofday( &t2, (struct timezone *) 0 );
  290.     (void) getrusage( RUSAGE_SELF, &ru2 );
  291.  
  292.     tvsub( &dt, &ru2.ru_utime, &ru_usr.ru_utime );
  293.     msu = dt.tv_sec * 1000 + (dt.tv_usec / 1000 );
  294.  
  295.     tvsub( &dt, &ru2.ru_stime, &ru_usr.ru_stime );
  296.     mss = dt.tv_sec * 1000 + (dt.tv_usec / 1000 );
  297.  
  298.     tvsub( &dt, &t2, &t_usr );
  299.     ms = dt.tv_sec * 1000 + (dt.tv_usec / 1000 );
  300.  
  301.     (void) sprintf( dest, "%ldu %lds %ld", msu, mss, ms );
  302.   }
  303.  
  304. #endif SYS_V
  305.